<!-- <script>
    // 简单工厂
    //    有一个工厂函数创建对象，而不是new出来的，是创建对象的方式之一

    // 下面的代码就是简单的工厂的创建
    // 工厂函数
    function createPerson(name, age, sex) {
        return {
            name: name,
            age: age,
            sex: sex,
            sayHello: function () {
                console.log("你好我是" + this.name + "今年" + this.age + "岁了，我是一个" + this.sex)
            }
        }
    };
    // malu  和  manman 都是Object的实例
    // 它们没有自己的对应的构造器
    var malu = createPerson("码路", 12, '男生');
    var manman = createPerson("漫漫", 13, "女生")
    console.log(malu);
    malu.sayHello();
    console.log(manman);
    manman.sayHello();
    console.log(malu instanceof Object);
</script> -->

<!-- <script>
    // 构造器函数
    function Car(color,doors){
        this.color = color;
        this.doors = doors;
    }
    Car.prototype.sayHello = function(){
        console.log("你好，我是小汽车，我的颜色是" + this.color + "色，一共有" + this.doors + "个门");
    }

    // 工厂函数
    function createCar(color,doors){
        return new Car(color, doors)
    }
    let car1 = createCar("红",2);
    let car2 = createCar("黑",4);
    console.log(car1);
    console.log(car2);
    console.log(car1 instanceof Car);
</script> -->

<!-- <script>
    // 普通工厂
    // 小汽车
    function Car(color, doors) {
        this.color = color;
        this.doors = doors;
        return this
    }
    // 大卡车
    function Trank(weight) {
        this.weight = weight;
        return this;
    }
    // 增强工厂函数
    // 可以创建各种各样的对象
    function createVihicle(type) {
        // 根据type进行判断，到底要创建什么样的对象
        if (type === "Car") {
            return Car.apply(new Car(), [].slice.call(arguments, 1))
        } else if (type === "Trank") {
            return Trank.apply(new Trank(), [].slice.call(arguments, 1))
        }
    }

    var xiaoqiche = new createVihicle("Car", "red", 4);
    var dakache = new createVihicle("Trank", 500)
    console.log(xiaoqiche)
    console.log(dakache)
    console.log(xiaoqiche instanceof Car)
    console.log(dakache instanceof Trank);
</script> -->

<script>
    // 抽象工厂就是提供一个注册方法，然后实例这个类。
    //  工厂维护一个类的清单，我们用一个对象来维持当前的所有的类内容，注册的时候可以提供预审查功能。
    //  比如我们要求所有的注册类都必须要有update和render方法，否则不允许注册

    // 构造函数
    function Duck(color, age) {
        this.color = color;
        this.age = age;
        return this;
    }
    Duck.prototype.update = function () { }
    Duck.prototype.render = function () { }

    // 构造函数
    function Chicken(color) {
        this.color = color;
        return this;
    }
    Chicken.prototype.update = function () { }
    Chicken.prototype.render = function () { }

    // 定义一个工厂函数
    var Factory = (function () {
        let types = {}; // 存储不同的构造函数，不同角色
        return {
            // 进行注册
            // 在注册时，可以进行预审查
            registFactory(type, typeFunction) {
                if (!typeFunction.prototype.update || !typeFunction.prototype.render) {
                    throw new Error(type + "类型没有注册成功，请设置update和render方法后，再进行注册")
                    return
                }
                // 给types对象注册方法
                types[type] = typeFunction
            },
            // 创建对象  生成对象
            careateActor(type) {
                return types[type].apply(new types[type](), [].slice.call(arguments, 1))
            }
        }
    })();
    // 注册
    Factory.registFactory("Duck", Duck);
    Factory.registFactory("Chicken", Chicken);

    // 实例，必须要先注册才能进行实例
    var yazi = Factory.careateActor("Duck", "黄", 1)
    var xiaoji = Factory.careateActor("Chicken", "红")
    console.log(yazi)
    console.log(xiaoji)
</script>